package com.fac.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fac.constant.CommonConstant;
import com.fac.constant.ExceptionConstant;
import com.fac.dto.RoleCreateDTO;
import com.fac.dto.RolePageQueryDTO;
import com.fac.dto.RoleUpdateDTO;
import com.fac.entity.Role;
import com.fac.entity.UserRoles;
import com.fac.exception.BusinessException;
import com.fac.mapper.RoleMapper;
import com.fac.mapper.UserRolesMapper;
import com.fac.result.PageResult;
import com.fac.service.RoleService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

/**
 * 角色服务实现类
 */
@Service
@Slf4j
public class RoleServiceImpl implements RoleService {

    @Autowired
    private RoleMapper roleMapper;

    @Autowired
    private UserRolesMapper userRolesMapper;

    /**
     * 创建角色
     *
     * @param roleCreateDTO 角色创建DTO
     * @return 创建的角色
     */
    @Override
    public Role create(RoleCreateDTO roleCreateDTO) {
        log.info("创建角色：{}", roleCreateDTO);

        // 创建角色实体
        Role role = new Role();
        BeanUtils.copyProperties(roleCreateDTO, role);

        // 设置状态为启用
        role.setStatus(CommonConstant.STATUS_ENABLE);

        // 插入数据库
        roleMapper.insert(role);

        return role;
    }

    /**
     * 分页查询角色
     *
     * @param rolePageQueryDTO 分页查询条件
     * @return 分页结果
     */
    @Override
    public PageResult pageQuery(RolePageQueryDTO rolePageQueryDTO) {
        log.info("分页查询角色：{}", rolePageQueryDTO);

        // 构建查询条件
        LambdaQueryWrapper<Role> queryWrapper = new LambdaQueryWrapper<>();
        
        // 添加关键字查询条件
        String keyword = rolePageQueryDTO.getKeyword();
        if (StringUtils.isNotEmpty(keyword)) {
            queryWrapper.like(Role::getName, keyword)
                    .or()
                    .like(Role::getCode, keyword)
                    .or()
                    .like(Role::getDescription, keyword);
        }

        // 创建分页对象
        Page<Role> page = new Page<>(rolePageQueryDTO.getPage(), rolePageQueryDTO.getSize());

        // 执行分页查询
        Page<Role> rolePage = roleMapper.selectPage(page, queryWrapper);

        // 返回分页结果
        return new PageResult(rolePage.getTotal(), rolePage.getRecords());
    }

    /**
     * 更新角色
     *
     * @param roleUpdateDTO 角色更新DTO
     * @return 更新后的角色
     */
    @Override
    @Transactional
    public Role update(RoleUpdateDTO roleUpdateDTO) {
        log.info("更新角色：{}", roleUpdateDTO);

        // 1. 检查角色是否存在
        Role existingRole = roleMapper.selectById(roleUpdateDTO.getRoleId());
        if (existingRole == null) {
            throw new BusinessException("角色不存在");
        }

        // 2. 检查角色编码是否已被其他角色使用
        if (!existingRole.getCode().equals(roleUpdateDTO.getCode())) {
            LambdaQueryWrapper<Role> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(Role::getCode, roleUpdateDTO.getCode())
                    .ne(Role::getRoleId, roleUpdateDTO.getRoleId());
            if (roleMapper.selectCount(queryWrapper) > 0) {
                throw new BusinessException(ExceptionConstant.ERROR_ROLE_CODE_EXISTS);
            }
        }

        // 3. 更新角色信息
        Role role = new Role();
        BeanUtils.copyProperties(roleUpdateDTO, role);
        
        // 4. 执行更新操作
        int rows = roleMapper.updateById(role);
        if (rows == 0) {
            throw new BusinessException("更新角色信息失败");
        }

        // 5. 返回更新后的角色信息
        return roleMapper.selectById(roleUpdateDTO.getRoleId());
    }

    /**
     * 删除角色
     *
     * @param roleId 角色ID
     */
    @Override
    @Transactional
    public void delete(Long roleId) {
        log.info("删除角色：{}", roleId);

        // 1. 检查角色是否存在
        Role role = roleMapper.selectById(roleId);
        if (role == null) {
            throw new BusinessException("角色不存在");
        }

        // 2. 检查角色是否已被用户使用
        LambdaQueryWrapper<UserRoles> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(UserRoles::getRoleId, roleId);
        if (userRolesMapper.selectCount(queryWrapper) > 0) {
            throw new BusinessException("该角色已被用户使用，无法删除");
        }

        // 3. 执行删除操作
        roleMapper.deleteById(roleId);
    }
} 